home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 1999 August / SGI Freeware 1999 August.iso / dist / fw_xemacs.idb / usr / freeware / lib / xemacs-20.4 / lisp / packages / supercite.el.z / supercite.el
Encoding:
Text File  |  1998-05-21  |  73.0 KB  |  2,164 lines
  1. ;;; supercite.el --- minor mode for citing mail and news replies
  2.  
  3. ;; Author: 1993 Barry A. Warsaw, Century Computing, Inc. <bwarsaw@python.org>
  4. ;; Maintainer:    supercite-help@python.org
  5. ;; Created:       February 1993
  6. ;; Version:       3.1
  7. ;; Last Modified: 1993/09/22 18:58:46
  8. ;; Keywords: citation attribution mail news article reply followup
  9.  
  10. ;; supercite.el revision: 3.55-x
  11.  
  12. ;; Copyright (C) 1993 Barry A. Warsaw
  13.  
  14. ;; This file is part of XEmacs.
  15.  
  16. ;; XEmacs is free software; you can redistribute it and/or modify it
  17. ;; under the terms of the GNU General Public License as published by
  18. ;; the Free Software Foundation; either version 2, or (at your option)
  19. ;; any later version.
  20.  
  21. ;; XEmacs is distributed in the hope that it will be useful, but
  22. ;; WITHOUT ANY WARRANTY; without even the implied warranty of
  23. ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24. ;; General Public License for more details.
  25.  
  26. ;; You should have received a copy of the GNU General Public License
  27. ;; along with XEmacs; see the file COPYING.  If not, write to the 
  28. ;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  29. ;; Boston, MA 02111-1307, USA.
  30.  
  31. ;;; Synched up with: FSF 19.28.
  32.  
  33. ;; LCD Archive Entry
  34. ;; supercite|Barry A. Warsaw|supercite-help@anthem.nlm.nih.gov
  35. ;; |Mail and news reply citation package
  36. ;; |1993/09/22 18:58:46|3.1|
  37.  
  38. ;; sb 1997/Apr/02:  Added attribution function sc-header-author-email-writes
  39. ;; which gives attribution in the form -
  40. ;; Steve Baur <steve@altair.xemacs.org> writes:
  41.  
  42. ;; Code:
  43.  
  44.  
  45. (require 'regi)
  46.  
  47. ;; start user configuration variables
  48. ;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
  49.  
  50. (defgroup supercite nil
  51.   "Supercite package"
  52.   :prefix "sc-"
  53.   :group 'mail
  54.   :group 'news)
  55.  
  56. (defgroup supercite-frames nil
  57.   "Supercite (regi) frames"
  58.   :prefix "sc-"
  59.   :group 'supercite)
  60.  
  61. (defgroup supercite-attr nil
  62.   "Supercite attributions"
  63.   :prefix "sc-"
  64.   :group 'supercite)
  65.  
  66. (defgroup supercite-cite nil
  67.   "Supercite citings"
  68.   :prefix "sc-"
  69.   :group 'supercite)
  70.  
  71. (defgroup supercite-hooks nil
  72.   "Hooking into supercite"
  73.   :prefix "sc-"
  74.   :group 'supercite)
  75.  
  76. (defcustom sc-auto-fill-region-p t
  77.   "*If non-nil, automatically fill each paragraph after it has been cited."
  78.   :type 'boolean
  79.   :group 'supercite)
  80.  
  81. (defcustom sc-blank-lines-after-headers 1
  82.   "*Number of blank lines to leave after mail headers have been nuked.
  83. Set to nil, to use whatever blank lines happen to occur naturally."
  84.   :type '(choice (const :tag "leave" nil)
  85.          integer)
  86.   :group 'supercite)
  87.  
  88. (defcustom sc-citation-leader "    "
  89.   "*String comprising first part of a citation."
  90.   :type 'string
  91.   :group 'supercite-cite)
  92.  
  93. (defcustom sc-citation-delimiter ">"
  94.   "*String comprising third part of a citation.
  95. This string is used in both nested and non-nested citations."
  96.   :type 'string
  97.   :group 'supercite-cite)
  98.  
  99. (defcustom sc-citation-separator " "
  100.   "*String comprising fourth and last part of a citation."
  101.   :type 'string
  102.   :group 'supercite-cite)
  103.  
  104. (defcustom sc-citation-leader-regexp "[ \t]*"
  105.   "*Regexp describing citation leader for a cited line.
  106. This should NOT have a leading `^' character."
  107.   :type 'regexp
  108.   :group 'supercite-cite)
  109.  
  110. ;; Nemacs and Mule users note: please see the texinfo manual for
  111. ;; suggestions on setting these variables.
  112. (defcustom sc-citation-root-regexp "[-._a-zA-Z0-9]*"
  113.   "*Regexp describing variable root part of a citation for a cited line.
  114. This should NOT have a leading `^' character.  See also
  115. `sc-citation-nonnested-root-regexp'."
  116.   :type 'regexp
  117.   :group 'supercite-cite)
  118.  
  119. (defcustom sc-citation-nonnested-root-regexp "[-._a-zA-Z0-9]+"
  120.   "*Regexp describing the variable root part of a nested citation.
  121. This should NOT have a leading `^' character.  This variable is
  122. related to `sc-citation-root-regexp' but where as that varariable
  123. describes both nested and non-nested citation roots, this variable
  124. describes only nested citation roots."
  125.   :type 'regexp
  126.   :group 'supercite-cite)
  127.  
  128. (defcustom sc-citation-delimiter-regexp "[>]+"
  129.   "*Regexp describing citation delimiter for a cited line.
  130. This should NOT have a leading `^' character."
  131.   :type 'regexp
  132.   :group 'supercite-cite)
  133.  
  134. (defcustom sc-citation-separator-regexp "[ \t]*"
  135.   "*Regexp describing citation separator for a cited line.
  136. This should NOT have a leading `^' character."
  137.   :type 'regexp
  138.   :group 'supercite-cite)
  139.  
  140. (defcustom sc-cite-blank-lines-p nil
  141.   "*If non-nil, put a citation on blank lines."
  142.   :type 'boolean
  143.   :group 'supercite-cite)
  144.  
  145. (defcustom sc-cite-frame-alist '()
  146.   "*Alist for frame selection during citing.
  147. Each element of this list has the following form:
  148.  
  149.    (INFOKEY ((REGEXP . FRAME)
  150.              (REGEXP . FRAME)
  151.              (...)))
  152.  
  153. Where INFOKEY is a key for `sc-mail-field', REGEXP is a regular
  154. expression to match against the INFOKEY's value.  FRAME is a citation
  155. frame, or a variable containing a citation frame."
  156.   :type '(repeat (list symbol (repeat (cons regexp
  157.                         (choice (repeat (repeat sexp))
  158.                             symbol)))))
  159.   :group 'supercite-frames)
  160.  
  161. (defcustom sc-uncite-frame-alist '()
  162.   "*Alist for frame selection during unciting.
  163. See the variable `sc-cite-frame-alist' for details."
  164.   :type '(repeat (list symbol (repeat (cons regexp
  165.                         (choice (repeat (repeat sexp))
  166.                             symbol)))))
  167.   :group 'supercite-frames)
  168.  
  169. (defcustom sc-recite-frame-alist '()
  170.   "*Alist for frame selection during reciting.
  171. See the variable `sc-cite-frame-alist' for details."
  172.   :type '(repeat (list symbol (repeat (cons regexp
  173.                         (choice (repeat (repeat sexp))
  174.                             symbol)))))
  175.   :group 'supercite-frames)
  176.  
  177. (defcustom sc-default-cite-frame
  178.   '(;; initialize fill state and temporary variables when entering
  179.     ;; frame. this makes things run much faster
  180.     (begin (progn
  181.          (sc-fill-if-different)
  182.          (setq sc-tmp-nested-regexp (sc-cite-regexp "")
  183.            sc-tmp-nonnested-regexp (sc-cite-regexp)
  184.            sc-tmp-dumb-regexp
  185.            (concat "\\("
  186.                (sc-cite-regexp "")
  187.                "\\)"
  188.                (sc-cite-regexp sc-citation-nonnested-root-regexp))
  189.            )))
  190.     ;; blank lines mean paragraph separators, so fill the last cited
  191.     ;; paragraph, unless sc-cite-blank-lines-p is non-nil, in which
  192.     ;; case we treat blank lines just like any other line.
  193.     ("^[ \t]*$"                 (if sc-cite-blank-lines-p
  194.                     (sc-cite-line)
  195.                   (sc-fill-if-different "")))
  196.     ;; do nothing if looking at a reference tag. make sure that the
  197.     ;; tag string isn't the empty string since this will match every
  198.     ;; line.  it cannot be nil.
  199.     (sc-reference-tag-string    (if (string= sc-reference-tag-string "")
  200.                     (list 'continue)
  201.                   nil))
  202.     ;; this regexp catches nested citations in which the author cited
  203.     ;; a non-nested citation with a dumb citer.
  204.     (sc-tmp-dumb-regexp         (sc-cite-coerce-dumb-citer))
  205.     ;; if we are looking at a nested citation then add a citation level
  206.     (sc-tmp-nested-regexp       (sc-add-citation-level))
  207.     ;; if we're looking at a non-nested citation, coerce it to our style
  208.     (sc-tmp-nonnested-regexp    (sc-cite-coerce-cited-line))
  209.     ;; we must be looking at an uncited line. if we are in nested
  210.     ;; citations, just add a citation level
  211.     (sc-nested-citation-p       (sc-add-citation-level))
  212.     ;; we're looking at an uncited line and we are in non-nested
  213.     ;; citations, so cite it with a non-nested citation
  214.     (t                          (sc-cite-line))
  215.     ;; be sure when we're done that we fill the last cited paragraph.
  216.     (end                        (sc-fill-if-different ""))
  217.     )
  218.   "*Default REGI frame for citing a region."
  219.   :type '(repeat (repeat sexp))
  220.   :group 'supercite-frames)
  221.  
  222. (defcustom sc-default-uncite-frame
  223.   '(;; do nothing on a blank line
  224.     ("^[ \t]*$"       nil)
  225.     ;; if the line is cited, uncite it
  226.     ((sc-cite-regexp) (sc-uncite-line))
  227.     )
  228.   "*Default REGI frame for unciting a region."
  229.   :type '(repeat (repeat sexp))
  230.   :group 'supercite-frames)
  231.  
  232. (defcustom sc-default-recite-frame
  233.   '(;; initialize fill state when entering frame
  234.     (begin            (sc-fill-if-different))
  235.     ;; do nothing on a blank line
  236.     ("^[ \t]*$"       nil)
  237.     ;; if we're looking at a cited line, recite it
  238.     ((sc-cite-regexp) (sc-recite-line (sc-cite-regexp)))
  239.     ;; otherwise, the line is uncited, so just cite it
  240.     (t                (sc-cite-line))
  241.     ;; be sure when we're done that we fill the last cited paragraph.
  242.     (end              (sc-fill-if-different ""))
  243.     )
  244.   "*Default REGI frame for reciting a region."
  245.   :type '(repeat (repeat sexp))
  246.   :group 'supercite-frames)
  247.  
  248. (defcustom sc-cite-region-limit t
  249.   "*This variable controls automatic citation of yanked text.
  250. Legal values are:
  251.  
  252. non-nil   -- cite the entire region, regardless of its size
  253. nil       -- do not cite the region at all
  254. <integer> -- a number indicating the threshold for citation.  When
  255.          the number of lines in the region is greater than this
  256.          value, a warning message will be printed and the region
  257.          will not be cited.  Lines in region are counted with
  258.          `count-lines'. 
  259.  
  260. The gathering of attribution information is not affected by the value
  261. of this variable.  The number of lines in the region is calculated
  262. *after* all mail headers are removed.  This variable is only consulted
  263. during the initial citing via `sc-cite-original'."
  264.   :type '(choice (const :tag "always cite" t)
  265.          (const :tag "do not cite" nil)
  266.          (integer :tag "citation threshold"))
  267.   :group 'supercite-cite)
  268.  
  269. (defcustom sc-confirm-always-p t
  270.   "*If non-nil, always confirm attribution string before citing text body."
  271.   :type 'boolean
  272.   :group 'supercite-attr)
  273.  
  274. (defcustom sc-default-attribution "Anon"
  275.   "*String used when author's attribution cannot be determined."
  276.   :type 'string
  277.   :group 'supercite-attr)
  278. (defcustom sc-default-author-name "Anonymous"
  279.   "*String used when author's name cannot be determined."
  280.   :type 'string
  281.   :group 'supercite-attr)
  282. (defcustom sc-downcase-p nil
  283.   "*Non-nil means downcase the attribution and citation strings."
  284.   :type 'boolean
  285.   :group 'supercite-attr
  286.   :group 'supercite-cite)
  287. (defcustom sc-electric-circular-p t
  288.   "*If non-nil, treat electric references as circular."
  289.   :type 'boolean
  290.   :group 'supercite-attr)
  291.  
  292. (defcustom sc-electric-mode-hook nil
  293.   "*Hook for `sc-electric-mode' electric references mode."
  294.   :type 'hook
  295.   :group 'supercite-hooks)
  296. (defcustom sc-electric-references-p nil
  297.   "*Use electric references if non-nil."
  298.   :type 'boolean
  299.   :group 'supercite)
  300.  
  301. (defcustom sc-fixup-whitespace-p nil
  302.   "*If non-nil, delete all leading white space before citing."
  303.   :type 'boolean
  304.   :group 'supercite)
  305.  
  306. (defcustom sc-load-hook nil
  307.   "*Hook which gets run once after Supercite loads."
  308.   :type 'hook
  309.   :group 'supercite-hooks)
  310. (defcustom sc-pre-hook nil
  311.   "*Hook which gets run before each invocation of `sc-cite-original'."
  312.   :type 'hook
  313.   :group 'supercite-hooks)
  314. (defcustom sc-post-hook nil
  315.   "*Hook which gets run after each invocation of `sc-cite-original'."
  316.   :type 'hook
  317.   :group 'supercite-hooks)
  318.  
  319. (defcustom sc-mail-warn-if-non-rfc822-p t
  320.   "*Warn if mail headers don't conform to RFC822."
  321.   :type 'boolean
  322.   :group 'supercite-attr)
  323. (defcustom sc-mumble ""
  324.   "*Value returned by `sc-mail-field' if field isn't in mail headers."
  325.   :type 'string
  326.   :group 'supercite-attr)
  327.  
  328. (defcustom sc-name-filter-alist
  329.   '(
  330.     ;; This first item removes any [bracketed] multi-word items in names.
  331.     ;; Each word is already split into a separate string when this filter is
  332.     ;; applied, hence the complexity of the expression.
  333.     ("\\[.*\\]\\|\\[[^\]]*\\|[^\[]*\\]" . any)
  334.     ("^\\(Mr\\|Mrs\\|Ms\\|Dr\\)[.]?$" . 0)
  335.     ("^\\(Jr\\|Sr\\)[.]?$" . last)
  336.     ("^ASTS$" . 0)
  337.     ("^[I]+$" . last))
  338.   "*Name list components which are filtered out as noise.
  339. This variable contains an association list where each element is of
  340. the form:  (REGEXP . POSITION).
  341.  
  342. REGEXP is a regular expression which matches the name list component.
  343. Match is performed using `string-match'.  POSITION is the position in
  344. the name list which can match the regular expression, starting at zero
  345. for the first element.  Use `last' to match the last element in the
  346. list and `any' to match all elements."
  347.   :type '(repeat (cons regexp (choice (const last) (const any)
  348.                       (integer :tag "position"))))
  349.   :group 'supercite-attr)
  350.  
  351. (defcustom sc-nested-citation-p nil
  352.   "*Controls whether to use nested or non-nested citation style.
  353. Non-nil uses nested citations, nil uses non-nested citations."
  354.   :type 'boolean
  355.   :group 'supercite)
  356.  
  357. (defcustom sc-nuke-mail-headers 'all
  358.   "*Controls mail header nuking.
  359. Used in conjunction with `sc-nuke-mail-header-list'.  Legal values are:
  360.  
  361. `all'       -- nuke all mail headers
  362. `none'      -- don't nuke any mail headers
  363. `specified' -- nuke headers specified in `sc-nuke-mail-header-list'
  364. `keep'      -- keep headers specified in `sc-nuke-mail-header-list'"
  365.   :type '(choice (const all) (const none)
  366.          (const specified) (const keep))
  367.   :group 'supercite)
  368.  
  369. (defcustom sc-nuke-mail-header-list nil
  370.   "*List of mail header regexps to remove or keep in body of reply.
  371. This list contains regular expressions describing the mail headers to
  372. keep or nuke, depending on the value of `sc-nuke-mail-headers'."
  373.   :type '(repeat regexp)
  374.   :group 'supercite)
  375.  
  376. (defcustom sc-preferred-attribution-list
  377.   '("sc-lastchoice" "x-attribution" "firstname" "initials" "lastname")
  378.   "*Specifies what to use as the attribution string.
  379. Supercite creates a list of possible attributions when it scans the
  380. mail headers from the original message.  Each attribution choice is
  381. associated with a key in an attribution alist.  Supercite tries to
  382. pick a \"preferred\" attribution by matching the attribution alist
  383. keys against the elements in `sc-preferred-attribution-list' in order.
  384. The first non-empty string value found is used as the preferred
  385. attribution.
  386.  
  387. Note that Supercite now honors the X-Attribution: mail field.  If
  388. present in the original message, the value of this field should always
  389. be used to select the most preferred attribution since it reflects how
  390. the original author would like to be distinguished.  It should be
  391. considered bad taste to put any attribution preference key before
  392. \"x-attribution\" in this list, except perhaps for \"sc-lastchoice\"
  393. \(see below).
  394.  
  395. Supercite remembers the last attribution used when reciting an already
  396. cited paragraph.  This attribution will always be saved with the
  397. \"sc-lastchoice\" key, which can be used in this list.  Note that the
  398. last choice is always reset after every call of `sc-cite-original'.
  399.  
  400. Barring error conditions, the following preferences are always present
  401. in the attribution alist:
  402.  
  403. \"emailname\"    -- email terminus name
  404. \"initials\"     -- initials of author
  405. \"firstname\"    -- first name of author
  406. \"lastname\"     -- last name of author
  407. \"middlename-1\" -- first middle name of author
  408. \"middlename-2\" -- second middle name of author
  409. ...
  410.  
  411. Middle name indexes can be any positive integer greater than 0,
  412. although it is unlikely that many authors will supply more than one
  413. middle name, if that many.  The string of all middle names is
  414. associated with the key \"middlenames\"."
  415.   :type '(repeat string)
  416.   :group 'supercite-attr)
  417.  
  418. (defcustom sc-attrib-selection-list nil
  419.   "*An alist for selecting preferred attribution based on mail headers.
  420. Each element of this list has the following form:
  421.  
  422.    (INFOKEY ((REGEXP . ATTRIBUTION)
  423.              (REGEXP . ATTRIBUTION)
  424.              (...)))
  425.  
  426. Where INFOKEY is a key for `sc-mail-field', REGEXP is a regular
  427. expression to match against the INFOKEY's value. ATTRIBUTION can be a
  428. string or a list.  If its a string, then it is the attribution that is
  429. selected by `sc-select-attribution'.  If it is a list, it is `eval'd
  430. and the return value must be a string, which is used as the selected
  431. attribution.  Note that the variable `sc-preferred-attribution-list'
  432. must contain an element of the string \"sc-consult\" for this variable
  433. to be consulted during attribution selection."
  434.   :type '(repeat (list symbol (repeat (cons regexp
  435.                         (choice (repeat (repeat sexp))
  436.                             symbol)))))
  437.   :group 'supercite-attr)
  438.  
  439. (defcustom sc-attribs-preselect-hook nil
  440.   "*Hook to run before selecting an attribution."
  441.   :type 'hook
  442.   :group 'supercite-attr
  443.   :group 'supercite-hooks)
  444. (defcustom sc-attribs-postselect-hook nil
  445.   "*Hook to run after selecting an attribution, but before confirmation."
  446.   :type 'hook
  447.   :group 'supercite-attr
  448.   :group 'supercite-hooks)
  449.  
  450. (defcustom sc-pre-cite-hook nil
  451.   "*Hook to run before citing a region of text."
  452.   :type 'hook
  453.   :group 'supercite-cite
  454.   :group 'supercite-hooks)
  455. (defcustom sc-pre-uncite-hook nil
  456.   "*Hook to run before unciting a region of text."
  457.   :type 'hook
  458.   :group 'supercite-cite
  459.   :group 'supercite-hooks)
  460. (defcustom sc-pre-recite-hook nil
  461.   "*Hook to run before reciting a region of text."
  462.   :type 'hook
  463.   :group 'supercite-cite
  464.   :group 'supercite-hooks)
  465.  
  466. (defcustom sc-preferred-header-style 4
  467.   "*Index into `sc-rewrite-header-list' specifying preferred header style.
  468. Index zero accesses the first function in the list."
  469.   :type 'integer
  470.   :group 'supercite)
  471.  
  472. (defcustom sc-reference-tag-string ">>>>> "
  473.   "*String used at the beginning of built-in reference headers."
  474.   :type 'string
  475.   :group 'supercite)
  476.  
  477. (defcustom sc-rewrite-header-list
  478.   '((sc-no-header)
  479.     (sc-header-on-said)
  480.     (sc-header-inarticle-writes)
  481.     (sc-header-regarding-adds)
  482.     (sc-header-attributed-writes)
  483.     (sc-header-author-writes)
  484.     (sc-header-verbose)
  485.     (sc-no-blank-line-or-header)
  486.     (sc-header-author-email-writes)
  487.     )
  488.   "*List of reference header rewrite functions.
  489. The variable `sc-preferred-header-style' controls which function in
  490. this list is chosen for automatic reference header insertions.
  491. Electric reference mode will cycle through this list of functions."
  492.   :type '(repeat sexp)
  493.   :group 'supercite)
  494.  
  495. (defcustom sc-titlecue-regexp "\\s +-+\\s +"
  496.   "*Regular expression describing the separator between names and titles.
  497. Set to nil to treat entire field as a name."
  498.   :type '(choice (const :tag "entire field as name" nil)
  499.          regexp)
  500.   :group 'supercite-attr)
  501.  
  502. (defcustom sc-use-only-preference-p nil
  503.   "*Controls what happens when the preferred attribution cannot be found.
  504. If non-nil, then `sc-default-attribution' will be used.  If nil, then
  505. some secondary scheme will be employed to find a suitable attribution
  506. string."
  507.   :type 'boolean
  508.   :group 'supercite-attr)
  509.  
  510. ;; ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  511. ;; end user configuration variables
  512.  
  513. (defconst sc-version "3.1"
  514.   "Supercite version number.")
  515. (defconst sc-help-address "supercite-help@anthem.nlm.nih.gov"
  516.   "Address accepting submissions of bug reports.")
  517.  
  518. (defvar sc-mail-info nil
  519.   "Alist of mail header information gleaned from reply buffer.")
  520. (defvar sc-attributions nil
  521.   "Alist of attributions for use when citing.")
  522.  
  523. (defconst sc-emacs-features
  524.   (let ((version 'v18)
  525.     (flavor  'GNU))
  526.     (if (or
  527.      (string= (substring emacs-version 0 2) "19")
  528.      (string= (substring emacs-version 0 2) "20"))
  529.     (setq version 'v19))
  530.     (if (string-match "XEmacs" emacs-version)
  531.     (setq flavor 'Lucid))
  532.     ;; cobble up list
  533.     (list version flavor))
  534.   "A list describing what version of Emacs we're running on.
  535. Known flavors are:
  536.  
  537. All GNU18's: (v18 GNU)
  538. FSF19.x    : (v19 GNU)
  539. Lucid19.x  : (v19 Lucid)")
  540.  
  541.  
  542. (defvar sc-tmp-nested-regexp nil
  543.   "Temporary regepx describing nested citations.")
  544. (defvar sc-tmp-nonnested-regexp nil
  545.   "Temporary regexp describing non-nested citations.")
  546. (defvar sc-tmp-dumb-regexp nil
  547.   "Temp regexp describing non-nested citation cited with a nesting citer.")
  548.  
  549. (defvar sc-minor-mode nil
  550.   "Supercite minor mode on flag.")
  551. (defvar sc-mode-string " SC"
  552.   "Supercite minor mode string.")
  553.  
  554. (make-variable-buffer-local 'sc-mail-info)
  555. (make-variable-buffer-local 'sc-attributions)
  556. (make-variable-buffer-local 'sc-minor-mode)
  557.  
  558.  
  559. ;; ======================================================================
  560. ;; supercite keymaps
  561.  
  562. (defvar sc-mode-map-prefix "\C-c\C-p"
  563.   "*Key binding to install Supercite keymap.
  564. If this is nil, Supercite keymap is not installed.")
  565.  
  566. (defvar sc-T-keymap ()
  567.   "Keymap for sub-keymap of setting and toggling functions.")
  568. (if sc-T-keymap
  569.     ()
  570.   (setq sc-T-keymap (make-sparse-keymap))
  571.   (define-key sc-T-keymap "a" 'sc-S-preferred-attribution-list)
  572.   (define-key sc-T-keymap "b" 'sc-T-mail-nuke-blank-lines)
  573.   (define-key sc-T-keymap "c" 'sc-T-confirm-always)
  574.   (define-key sc-T-keymap "d" 'sc-T-downcase)
  575.   (define-key sc-T-keymap "e" 'sc-T-electric-references)
  576.   (define-key sc-T-keymap "f" 'sc-T-auto-fill-region)
  577.   (define-key sc-T-keymap "h" 'sc-T-describe)
  578.   (define-key sc-T-keymap "l" 'sc-S-cite-region-limit)
  579.   (define-key sc-T-keymap "n" 'sc-S-mail-nuke-mail-headers)
  580.   (define-key sc-T-keymap "N" 'sc-S-mail-header-nuke-list)
  581.   (define-key sc-T-keymap "o" 'sc-T-electric-circular)
  582.   (define-key sc-T-keymap "p" 'sc-S-preferred-header-style)
  583.   (define-key sc-T-keymap "s" 'sc-T-nested-citation)
  584.   (define-key sc-T-keymap "u" 'sc-T-use-only-preferences)
  585.   (define-key sc-T-keymap "w" 'sc-T-fixup-whitespace)
  586.   (define-key sc-T-keymap "?" 'sc-T-describe)
  587.   )
  588.  
  589. (defvar sc-mode-map ()
  590.   "Keymap for Supercite quasi-mode.")
  591. (if sc-mode-map
  592.     ()
  593.   (setq sc-mode-map (make-sparse-keymap))
  594.   (define-key sc-mode-map "c"    'sc-cite-region)
  595.   (define-key sc-mode-map "f"    'sc-mail-field-query)
  596.   (define-key sc-mode-map "g"    'sc-mail-process-headers)
  597.   (define-key sc-mode-map "h"    'sc-describe)
  598.   (define-key sc-mode-map "i"    'sc-insert-citation)
  599.   (define-key sc-mode-map "o"    'sc-open-line)
  600.   (define-key sc-mode-map "r"    'sc-recite-region)
  601.   (define-key sc-mode-map "\C-p" 'sc-raw-mode-toggle)
  602.   (define-key sc-mode-map "u"    'sc-uncite-region)
  603.   (define-key sc-mode-map "v"    'sc-version)
  604.   (define-key sc-mode-map "w"    'sc-insert-reference)
  605.   (define-key sc-mode-map "\C-t"  sc-T-keymap)
  606.   (define-key sc-mode-map "\C-b" 'sc-submit-bug-report)
  607.   (define-key sc-mode-map "?"    'sc-describe)
  608.   )
  609.   
  610. (defvar sc-electric-mode-map ()
  611.   "Keymap for `sc-electric-mode' electric references mode.")
  612. (if sc-electric-mode-map
  613.     nil
  614.   (setq sc-electric-mode-map (make-sparse-keymap))
  615.   (define-key sc-electric-mode-map "p"    'sc-eref-prev)
  616.   (define-key sc-electric-mode-map "n"    'sc-eref-next)
  617.   (define-key sc-electric-mode-map "s"    'sc-eref-setn)
  618.   (define-key sc-electric-mode-map "j"    'sc-eref-jump)
  619.   (define-key sc-electric-mode-map "x"    'sc-eref-abort)
  620.   (define-key sc-electric-mode-map "q"    'sc-eref-abort)
  621.   (define-key sc-electric-mode-map "\r"   'sc-eref-exit)
  622.   (define-key sc-electric-mode-map "\n"   'sc-eref-exit)
  623.   (define-key sc-electric-mode-map "g"    'sc-eref-goto)
  624.   (define-key sc-electric-mode-map "?"    'describe-mode)
  625.   (define-key sc-electric-mode-map "\C-h" 'describe-mode)
  626.   )
  627.  
  628. (defvar sc-minibuffer-local-completion-map nil
  629.   "Keymap for minibuffer confirmation of attribution strings.")
  630. (if sc-minibuffer-local-completion-map
  631.     ()
  632.   (setq sc-minibuffer-local-completion-map
  633.     (copy-keymap minibuffer-local-completion-map))
  634.   (define-key sc-minibuffer-local-completion-map "\C-t" 'sc-toggle-fn)
  635.   (define-key sc-minibuffer-local-completion-map " "    'self-insert-command))
  636.  
  637. (defvar sc-minibuffer-local-map nil
  638.   "Keymap for minibuffer confirmation of attribution strings.")
  639. (if sc-minibuffer-local-map
  640.     ()
  641.   (setq sc-minibuffer-local-map (copy-keymap minibuffer-local-map))
  642.   (define-key sc-minibuffer-local-map "\C-t" 'sc-toggle-fn))
  643.  
  644.  
  645. ;; ======================================================================
  646. ;; utility functions
  647.  
  648. (defun sc-completing-read (prompt table &optional predicate require-match
  649.                   initial-contents history)
  650.   "Compatibility between Emacs 18 and 19 `completing-read'.
  651. In version 18, the HISTORY argument is ignored."
  652.   (if (memq 'v19 sc-emacs-features)
  653.       (funcall 'completing-read prompt table predicate require-match
  654.            initial-contents history)
  655.     (funcall 'completing-read prompt table predicate require-match
  656.          (or (car-safe initial-contents)
  657.          initial-contents))))
  658.  
  659. (defun sc-read-string (prompt &optional initial-contents history)
  660.   "Compatibility between Emacs 18 and 19 `read-string'.
  661. In version 18, the HISTORY argument is ignored."
  662.   (if (memq 'v19 sc-emacs-features)
  663.       (funcall 'read-string prompt initial-contents history)
  664.     (funcall 'read-string prompt initial-contents)))
  665.  
  666. (defun sc-submatch (matchnum &optional string)
  667.   "Returns `match-beginning' and `match-end' sub-expression for MATCHNUM.
  668. If optional STRING is provided, take sub-expression using `substring'
  669. of argument, otherwise use `buffer-substring' on current buffer.  Note
  670. that `match-data' must have already been generated and no error
  671. checking is performed by this function."
  672.   (if string
  673.       (substring string (match-beginning matchnum) (match-end matchnum))
  674.     (buffer-substring (match-beginning matchnum) (match-end matchnum))))
  675.  
  676. (defun sc-member (elt list)
  677.   "Like `memq', but uses `equal' instead of `eq'.
  678. Emacs19 has a builtin function `member' which does exactly this."
  679.   (catch 'elt-is-member
  680.     (while list
  681.       (if (equal elt (car list))
  682.       (throw 'elt-is-member list))
  683.       (setq list (cdr list)))))
  684. (and (memq 'v19 sc-emacs-features)
  685.      (fset 'sc-member 'member))
  686.  
  687. (defun sc-ask (alist)
  688.   "Ask a question in the minibuffer requiring a single character answer.
  689. This function is kind of an extension of `y-or-n-p' where a single
  690. letter is used to answer a question.  Question is formed from ALIST
  691. which has members of the form:  (WORD . LETTER).  WORD is the long
  692. word form, while LETTER is the letter for selecting that answer.  The
  693. selected letter is returned, or nil if the question was not answered.
  694. Note that WORD is a string and LETTER is a character.  All LETTERs in
  695. the list should be unique."
  696.   (let* ((prompt (concat
  697.           (mapconcat (function (lambda (elt) (car elt))) alist ", ")
  698.           "? ("
  699.           (mapconcat
  700.            (function
  701.             (lambda (elt) (char-to-string (cdr elt)))) alist "/")
  702.           ") "))
  703.      (p prompt)
  704.      (event
  705.       (if (memq 'Lucid sc-emacs-features)
  706.           (allocate-event)
  707.         nil)))
  708.     (while (stringp p)
  709.       (if (let ((cursor-in-echo-area t)
  710.         (inhibit-quit t))
  711.         (message "%s" p)
  712.         ;; lets be good neighbors and be compatible with all emacsen
  713.         (cond
  714.          ((memq 'v18 sc-emacs-features)
  715.           (setq event (read-char)))
  716.          ((memq 'Lucid sc-emacs-features)
  717.           (next-command-event event))
  718.          (t                ; must be FSF19
  719.           (setq event (read-event))))
  720.         (prog1 quit-flag (setq quit-flag nil)))
  721.       (progn
  722.         (message "%s%s" p (single-key-description event))
  723.         (and (memq 'Lucid sc-emacs-features)
  724.          (deallocate-event event))
  725.         (setq quit-flag nil)
  726.         (signal 'quit '())))
  727.       (let ((char
  728.          (if (memq 'Lucid sc-emacs-features)
  729.          (let* ((key (and (key-press-event-p event) (event-key event)))
  730.             (char (and key (event-to-character event))))
  731.            char)
  732.            event))
  733.         elt)
  734.     (if char (setq char (downcase char)))
  735.     (cond
  736.      ((setq elt (rassq char alist))
  737.       (message "%s%s" p (car elt))
  738.       (setq p (cdr elt)))
  739.      ((and (memq 'Lucid sc-emacs-features)
  740.            (button-release-event-p event)) ; ignore them
  741.       nil)
  742.      (t
  743.       (message "%s%s" p (single-key-description event))
  744.       (if (memq 'Lucid sc-emacs-features)
  745.           (ding nil 'y-or-n-p)
  746.         (ding))
  747.       (discard-input)
  748.       (if (eq p prompt)
  749.           (setq p (concat "Try again.  " prompt)))))))
  750.     (and (memq 'Lucid sc-emacs-features)
  751.      (deallocate-event event))
  752.     p))
  753.  
  754. (defun sc-scan-info-alist (alist)
  755.   "Find a match in the info alist that matches a regexp in ALIST."
  756.   (let ((sc-mumble "")
  757.     rtnvalue)
  758.     (while alist
  759.       (let* ((elem    (car alist))
  760.          (infokey (car elem))
  761.          (infoval (sc-mail-field infokey))
  762.          (mlist   (car (cdr elem))))
  763.     (while mlist
  764.       (let* ((ml-elem (car mlist))
  765.          (regexp  (car ml-elem))
  766.          (thing   (cdr ml-elem)))
  767.         (if (string-match regexp infoval)
  768.         ;; we found a match, time to return
  769.         (setq rtnvalue thing
  770.               mlist nil
  771.               alist nil)
  772.           ;; else we didn't find a match
  773.           (setq mlist (cdr mlist))
  774.           )))            ;end of mlist loop
  775.     (setq alist (cdr alist))
  776.     ))                ;end of alist loop
  777.     rtnvalue))
  778.  
  779.  
  780. ;; ======================================================================
  781. ;; extract mail field information from headers in reply buffer
  782.  
  783. ;; holder variables for bc happiness
  784. (defvar sc-mail-headers-start nil
  785.   "Start of header fields.")
  786. (defvar sc-mail-headers-end nil
  787.   "End of header fields.")
  788. (defvar sc-mail-field-history nil
  789.   "For minibuffer completion on mail field queries.")
  790. (defvar sc-mail-field-modification-history nil
  791.   "For minibuffer completion on mail field modifications.")
  792. (defvar sc-mail-glom-frame
  793.   '((begin                        (setq sc-mail-headers-start (point)))
  794.     ("^x-attribution:[ \t]+.*$"   (sc-mail-fetch-field t) nil t)
  795.     ("^\\S +:.*$"                 (sc-mail-fetch-field) nil t)
  796.     ("^$"                         (list 'abort '(step . 0)))
  797.     ("^[ \t]+"                    (sc-mail-append-field))
  798.     (sc-mail-warn-if-non-rfc822-p (sc-mail-error-in-mail-field))
  799.     (end                          (setq sc-mail-headers-end (point))))
  800.   "Regi frame for glomming mail header information.")
  801.  
  802. ;; regi functions
  803. (defun sc-mail-fetch-field (&optional attribs-p)
  804.   "Insert a key and value into `sc-mail-info' alist.
  805. If optional ATTRIBS-P is non-nil, the key/value pair is placed in
  806. `sc-attributions' too."
  807.   (if (string-match "^\\(\\S *\\)\\s *:\\s +\\(.*\\)$" curline)
  808.       (let* ((key (downcase (sc-submatch 1 curline)))
  809.          (val (sc-submatch 2 curline))
  810.          (keyval (cons key val)))
  811.     (setq sc-mail-info (cons keyval sc-mail-info))
  812.     (if attribs-p
  813.         (setq sc-attributions (cons keyval sc-attributions)))
  814.     ))
  815.   nil)
  816.  
  817. (defun sc-mail-append-field ()
  818.   "Append a continuation line onto the last fetched mail field's info."
  819.   (let ((keyval (car sc-mail-info)))
  820.     (if (and keyval (string-match "^\\s *\\(.*\\)$" curline))
  821.     (setcdr keyval (concat (cdr keyval) " " (sc-submatch 1 curline)))))
  822.   nil)
  823.  
  824. (defun sc-mail-error-in-mail-field ()
  825.   "Issue warning that mail headers don't conform to RFC 822."
  826.   (let* ((len (min (length curline) 10))
  827.      (ellipsis (if (< len (length curline)) "..." ""))
  828.      (msg "Mail header \"%s%s\" doesn't conform to RFC 822. skipping..."))
  829.     (message msg (substring curline 0 len) ellipsis))
  830.   (beep)
  831.   (sit-for 2)
  832.   nil)
  833.  
  834. ;; mail header nuking
  835. (defvar sc-mail-last-header-nuked-p nil
  836.   "True if the last header was nuked.")
  837.  
  838. (defun sc-mail-nuke-line ()
  839.   "Nuke the current mail header line."
  840.   (delete-region (regi-pos 'bol) (regi-pos 'bonl))
  841.   '((step . -1)))
  842.  
  843. (defun sc-mail-nuke-header-line ()
  844.   "Delete current-line and set up for possible continuation."
  845.   (setq sc-mail-last-header-nuked-p t)
  846.   (sc-mail-nuke-line))
  847.  
  848. (defun sc-mail-nuke-continuation-line ()
  849.   "Delete a continuation line if the last header line was deleted."
  850.   (if sc-mail-last-header-nuked-p
  851.       (sc-mail-nuke-line)))
  852.  
  853. (defun sc-mail-cleanup-blank-lines ()
  854.   "Leave some blank lines after original mail headers are nuked.
  855. The number of lines left is specified by `sc-blank-lines-after-headers'."
  856.   (if sc-blank-lines-after-headers
  857.       (save-restriction
  858.     (widen)
  859.     (skip-chars-backward " \t\n")
  860.     (forward-line 1)
  861.     (delete-blank-lines)
  862.     (beginning-of-line)
  863.     (if (looking-at "[ \t]*$")
  864.         (delete-region (regi-pos 'bol) (regi-pos 'bonl)))
  865.     (insert-char ?\n sc-blank-lines-after-headers)))
  866.   nil)
  867.  
  868. (defun sc-mail-build-nuke-frame ()
  869.   "Build the regiframe for nuking mail headers."
  870.   (let (every-func entry-func nonentry-func)
  871.     (cond
  872.      ((eq sc-nuke-mail-headers 'all)
  873.       (setq every-func '(progn (forward-line -1) (sc-mail-nuke-line))))
  874.      ((eq sc-nuke-mail-headers 'specified)
  875.       (setq entry-func    '(sc-mail-nuke-header-line)
  876.         nonentry-func '(setq sc-mail-last-header-nuked-p nil)))
  877.      ((eq sc-nuke-mail-headers 'keep)
  878.       (setq entry-func    '(setq sc-mail-last-header-nuked-p nil)
  879.         nonentry-func '(sc-mail-nuke-header-line)))
  880.      ;; we never get far enough to interpret a frame if s-n-m-h == 'none
  881.      ((eq sc-nuke-mail-headers 'none))
  882.      (t (error "Illegal value for sc-nuke-mail-headers: %s"
  883.            sc-nuke-mail-headers))
  884.      )                    ; end-cond
  885.     (append
  886.      (and entry-func
  887.       (regi-mapcar sc-nuke-mail-header-list entry-func nil t))
  888.      (and nonentry-func (list (list "^\\S +:.*$" nonentry-func)))
  889.      (and (not every-func)
  890.       '(("^[ \t]+" (sc-mail-nuke-continuation-line))))
  891.      '((begin     (setq sc-mail-last-header-zapped-p nil)))
  892.      '((end       (sc-mail-cleanup-blank-lines)))
  893.      (and every-func (list (list 'every every-func)))
  894.      )))
  895.  
  896. ;; mail processing and zapping. this is the top level entry defun to
  897. ;; all header processing.
  898. (defun sc-mail-process-headers (start end)
  899.   "Process original mail message's mail headers.
  900. After processing, mail headers may be nuked.  Header information is
  901. stored in `sc-mail-info', and any old information is lost unless an
  902. error occurs."
  903.   (interactive "r")
  904.   (let ((info (copy-alist sc-mail-info))
  905.     (attribs (copy-alist sc-attributions)))
  906.     (setq sc-mail-info nil
  907.       sc-attributions nil)
  908.     (regi-interpret sc-mail-glom-frame start end)
  909.     (if (null sc-mail-info)
  910.     (progn
  911.       (message "No mail headers found! Restoring old information.")
  912.       (setq sc-mail-info info
  913.         sc-attributions attribs))
  914.       (regi-interpret (sc-mail-build-nuke-frame)
  915.               sc-mail-headers-start sc-mail-headers-end)
  916.       )))
  917.  
  918.  
  919. ;; let the user change mail field information
  920. (defun sc-mail-field (field)
  921.   "Return the mail header field value associated with FIELD.
  922. If there was no mail header with FIELD as its key, return the value of
  923. `sc-mumble'.  FIELD is case insensitive."
  924.   (or (cdr (assoc (downcase field) sc-mail-info)) sc-mumble))
  925.  
  926. (defun sc-mail-field-query (arg)
  927.   "View the value of a mail field.
  928. With `\\[universal-argument]', prompts for action on mail field.
  929. Action can be one of: View, Modify, Add, or Delete."
  930.   (interactive "P")
  931.   (let* ((alist '(("view" . ?v) ("modify" . ?m) ("add" . ?a) ("delete" . ?d)))
  932.      (action (if (not arg) ?v (sc-ask alist)))
  933.      key)
  934.     (if (not action)
  935.     ()
  936.       (setq key (sc-completing-read
  937.          (concat (car (rassq action alist))
  938.                   " information key: ")
  939.          sc-mail-info nil
  940.          (if (eq action ?a) nil 'noexit)
  941.          nil 'sc-mail-field-history))
  942.       (cond
  943.        ((eq action ?v)
  944.     (message "%s: %s" key (cdr (assoc key sc-mail-info))))
  945.        ((eq action ?d)
  946.     (setq sc-mail-info (delq (assoc key sc-mail-info) sc-mail-info)))
  947.        ((eq action ?m)
  948.     (let ((keyval (assoc key sc-mail-info)))
  949.       ;; first put initial value onto list if not already there
  950.       (if (not (sc-member (cdr keyval)
  951.                   sc-mail-field-modification-history))
  952.           (setq sc-mail-field-modification-history
  953.             (cons (cdr keyval) sc-mail-field-modification-history)))
  954.       (setcdr keyval (sc-read-string
  955.               (concat key ": ") (cdr keyval)
  956.               'sc-mail-field-modification-history))))
  957.        ((eq action ?a)
  958.     (setq sc-mail-info
  959.           (cons (cons key
  960.               (sc-read-string (concat key ": "))) sc-mail-info)))
  961.        ))))
  962.  
  963.  
  964. ;; ======================================================================
  965. ;; attributions
  966.  
  967. (defvar sc-attribution-confirmation-history nil
  968.   "History for confirmation of attribution strings.")
  969. (defvar sc-citation-confirmation-history nil
  970.   "History for confirmation of attribution prefixes.")
  971.  
  972. (defun sc-attribs-%@-addresses (from &optional delim)
  973.   "Extract the author's email terminus from email address FROM.
  974. Match addresses of the style ``name%[stuff].'' when called with DELIM
  975. of \"%\" and addresses of the style ``[stuff]name@[stuff]'' when
  976. called with DELIM \"@\".  If DELIM is nil or not provided, matches
  977. addresses of the style ``name''."
  978.   (and (string-match (concat "[-+a-zA-Z0-9_.]+" delim) from 0)
  979.        (substring from
  980.           (match-beginning 0)
  981.           (- (match-end 0) (if (null delim) 0 1)))))
  982.  
  983. (defun sc-attribs-!-addresses (from)
  984.   "Extract the author's email terminus from email address FROM.
  985. Match addresses of the style ``[stuff]![stuff]...!name[stuff].''"
  986.   (let ((eos (length from))
  987.     (mstart (string-match "![-a-zA-Z0-9_.]+\\([^-!a-zA-Z0-9_.]\\|$\\)"
  988.                   from 0))
  989.     (mend (match-end 0)))
  990.     (and mstart
  991.      (substring from (1+ mstart) (- mend (if (= mend eos) 0 1)))
  992.      )))
  993.  
  994. (defun sc-attribs-<>-addresses (from)
  995.   "Extract the author's email terminus from email address FROM.
  996. Match addresses of the style ``<name[stuff]>.''"
  997.   (and (string-match "<\\(.*\\)>" from)
  998.        (sc-submatch 1 from)))
  999.  
  1000. (defun sc-get-address (from author)
  1001.   "Get the full email address path from FROM.
  1002. AUTHOR is the author's name (which is removed from the address)."
  1003.   (let ((eos (length from)))
  1004.     (if (string-match (concat "\\(^\\|^\"\\)" author
  1005.                   "\\(\\s +\\|\"\\s +\\)") from 0)
  1006.     (let ((address (substring from (match-end 0) eos)))
  1007.       (if (and (= (aref address 0) ?<)
  1008.            (= (aref address (1- (length address))) ?>))
  1009.           (substring address 1 (1- (length address)))
  1010.         address))
  1011.       (if (string-match "[-+a-zA-Z0-9!@%._]+" from 0)
  1012.       (sc-submatch 0 from)
  1013.     "")
  1014.       )))
  1015.  
  1016. (defun sc-attribs-emailname (from)
  1017.   "Get the email terminus name from FROM."
  1018.   (or
  1019.    (sc-attribs-%@-addresses from "%")
  1020.    (sc-attribs-%@-addresses from "@")
  1021.    (sc-attribs-!-addresses  from)
  1022.    (sc-attribs-<>-addresses from)
  1023.    (sc-attribs-%@-addresses from)
  1024.    (substring from 0 10)))
  1025.  
  1026. (defun sc-name-substring (string start end extend)
  1027.   "Extract the specified substring of STRING from START to END.
  1028. EXTEND is the number of characters on each side to extend the
  1029. substring."
  1030.   (and start
  1031.        (let ((sos (+ start extend))
  1032.          (eos (- end extend)))
  1033.      (substring string sos
  1034.             (or (string-match sc-titlecue-regexp string sos) eos)
  1035.             ))))
  1036.  
  1037. (defun sc-attribs-extract-namestring (from)
  1038.   "Extract the name string from FROM.
  1039. This should be the author's full name minus an optional title."
  1040.   (let ((namestring
  1041.      (or
  1042.       (sc-name-substring
  1043.        from (string-match "(.*)" from 0) (match-end 0) 1)
  1044.       (sc-name-substring
  1045.        from (string-match "\".*\"" from 0) (match-end 0) 1)
  1046.       (sc-name-substring
  1047.        from (string-match "\\([-.a-zA-Z0-9_]+\\s +\\)+<" from 0)
  1048.        (match-end 1) 0)
  1049.       (sc-attribs-emailname from))))
  1050.     ;; strip off any leading or trailing whitespace
  1051.     (if namestring
  1052.     (let ((bos 0)
  1053.           (eos (1- (length namestring))))
  1054.       (while (and (<= bos eos)
  1055.               (memq (aref namestring bos) '(?\  ?\t)))
  1056.         (setq bos (1+ bos)))
  1057.       (while (and (> eos bos)
  1058.               (memq (aref namestring eos) '(?\  ?\t)))
  1059.         (setq eos (1- eos)))
  1060.       (substring namestring bos (1+ eos))))))
  1061.  
  1062. (defun sc-attribs-chop-namestring (namestring)
  1063.   "Convert NAMESTRING to a list of names.
  1064. example: (sc-namestring-to-list \"John Xavier Doe\")
  1065.          => (\"John\" \"Xavier\" \"Doe\")"
  1066.   (if (string-match "\\([ \t]*\\)\\([^ \t._]+\\)\\([ \t]*\\)" namestring)
  1067.       (cons (sc-submatch 2 namestring)
  1068.         (sc-attribs-chop-namestring (substring namestring (match-end 3)))
  1069.         )))
  1070.  
  1071. (defun sc-attribs-strip-initials (namelist)
  1072.   "Extract the author's initials from the NAMELIST."
  1073.   (mapconcat
  1074.    (function
  1075.     (lambda (name)
  1076.       (if (< 0 (length name))
  1077.       (substring name 0 1))))
  1078.    namelist ""))
  1079.  
  1080. (defun sc-guess-attribution (&optional string)
  1081.   "Guess attribution string on current line.
  1082. If attribution cannot be guessed, nil is returned.  Optional STRING if
  1083. supplied, is used instead of the line point is on in the current buffer."
  1084.   (let ((start 0)
  1085.     (string (or string (buffer-substring (regi-pos 'bol) (regi-pos 'eol))))
  1086.     attribution)
  1087.     (and
  1088.      (= start (or (string-match sc-citation-leader-regexp string start) -1))
  1089.      (setq start (match-end 0))
  1090.      (= start (or (string-match sc-citation-root-regexp string start) 1))
  1091.      (setq attribution (sc-submatch 0 string)
  1092.        start (match-end 0))
  1093.      (= start (or (string-match sc-citation-delimiter-regexp string start) -1))
  1094.      (setq start (match-end 0))
  1095.      (= start (or (string-match sc-citation-separator-regexp string start) -1))
  1096.      attribution)))
  1097.  
  1098. (defun sc-attribs-filter-namelist (namelist)
  1099.   "Filter out noise in NAMELIST according to `sc-name-filter-alist'."
  1100.   (let ((elements (length namelist))
  1101.     (position -1)
  1102.     keepers filtered-list)
  1103.     (mapcar
  1104.      (function
  1105.       (lambda (name)
  1106.     (setq position (1+ position))
  1107.     (let ((keep-p t))
  1108.       (mapcar
  1109.        (function
  1110.         (lambda (filter)
  1111.           (let ((regexp (car filter))
  1112.             (pos (cdr filter)))
  1113.         (if (and (string-match regexp name)
  1114.              (or (and (numberp pos)
  1115.                   (= pos position))
  1116.                  (and (eq pos 'last)
  1117.                   (= position (1- elements)))
  1118.                  (eq pos 'any)))
  1119.             (setq keep-p nil))
  1120.         )))
  1121.        sc-name-filter-alist)
  1122.       (if keep-p
  1123.           (setq keepers (cons position keepers)))
  1124.       )))
  1125.      namelist)
  1126.     (mapcar
  1127.      (function
  1128.       (lambda (position)
  1129.     (setq filtered-list (cons (nth position namelist) filtered-list))
  1130.     ))
  1131.      keepers)
  1132.     filtered-list))
  1133.  
  1134. (defun sc-attribs-chop-address (from)
  1135.   "Extract attribution information from FROM.
  1136. This populates the `sc-attributions' with the list of possible attributions."
  1137.   (if (and (stringp from)
  1138.        (< 0 (length from)))
  1139.       (let* ((sc-mumble "")         
  1140.          (namestring (sc-attribs-extract-namestring from))
  1141.          (namelist   (sc-attribs-filter-namelist
  1142.               (sc-attribs-chop-namestring namestring)))
  1143.          (revnames   (reverse (cdr namelist)))
  1144.          (firstname  (car namelist))
  1145.          (midnames   (reverse (cdr revnames)))
  1146.          (lastname   (car revnames))
  1147.          (initials   (sc-attribs-strip-initials namelist))
  1148.          (emailname  (sc-attribs-emailname from))
  1149.          (n 1)
  1150.          author middlenames)
  1151.     
  1152.     ;; put basic information
  1153.     (setq
  1154.      ;; put middle names and build sc-author entry
  1155.      middlenames (mapconcat
  1156.               (function
  1157.                (lambda (midname)
  1158.              (let ((key-attribs (format "middlename-%d" n))
  1159.                    (key-mail    (format "sc-middlename-%d" n)))
  1160.                (setq
  1161.                 sc-attributions (cons (cons key-attribs midname)
  1162.                           sc-attributions)
  1163.                 sc-mail-info (cons (cons key-mail midname)
  1164.                            sc-mail-info)
  1165.                 n (1+ n))
  1166.                midname)))
  1167.               midnames " ")
  1168.  
  1169.      author (concat firstname " " middlenames (and midnames " ") lastname)
  1170.  
  1171.      sc-attributions (append
  1172.               (list
  1173.                (cons "firstname"   firstname)
  1174.                (cons "lastname"    lastname)
  1175.                (cons "emailname"   emailname)
  1176.                (cons "initials"    initials))
  1177.               sc-attributions)
  1178.      sc-mail-info (append
  1179.                (list
  1180.             (cons "sc-firstname"   firstname)
  1181.             (cons "sc-middlenames" middlenames)
  1182.             (cons "sc-lastname"    lastname)
  1183.             (cons "sc-emailname"   emailname)
  1184.             (cons "sc-initials"    initials)
  1185.             (cons "sc-author"      author)
  1186.             (cons "sc-from-address" (sc-get-address
  1187.                          (sc-mail-field "from")
  1188.                          namestring))
  1189.             (cons "sc-reply-address" (sc-get-address
  1190.                           (sc-mail-field "reply-to")
  1191.                           namestring))
  1192.             (cons "sc-sender-address" (sc-get-address
  1193.                            (sc-mail-field "sender")
  1194.                            namestring))
  1195.             )
  1196.                sc-mail-info)
  1197.      ))
  1198.     ;; from string is empty
  1199.     (setq sc-mail-info (cons (cons "sc-author" sc-default-author-name)
  1200.                  sc-mail-info))))
  1201.  
  1202. (defvar sc-attrib-or-cite nil
  1203.   "Used to toggle between attribution input or citation input.")
  1204.  
  1205. (defun sc-toggle-fn ()
  1206.   "Toggle between attribution selection and citation selection.
  1207. Only used during confirmation."
  1208.   (interactive)
  1209.   (setq sc-attrib-or-cite (not sc-attrib-or-cite))
  1210.   (throw 'sc-reconfirm t))
  1211.  
  1212. (defun sc-select-attribution ()
  1213.   "Select an attribution from `sc-attributions'.
  1214.  
  1215. Variables involved in selection process include:
  1216.      `sc-preferred-attribution-list'
  1217.      `sc-use-only-preference-p'
  1218.      `sc-confirm-always-p'
  1219.      `sc-default-attribution'
  1220.      `sc-attrib-selection-list'.
  1221.  
  1222. Runs the hook `sc-attribs-preselect-hook' before selecting an
  1223. attribution and the hook `sc-attribs-postselect-hook' after making the
  1224. selection but before querying is performed.  During
  1225. `sc-attribs-postselect-hook' the variable `citation' is bound to the
  1226. auto-selected citation string and the variable `attribution' is bound
  1227. to the auto-selected attribution string."
  1228.   (run-hooks 'sc-attribs-preselect-hook)
  1229.   (let ((query-p sc-confirm-always-p)
  1230.     attribution citation
  1231.     (attriblist sc-preferred-attribution-list))
  1232.  
  1233.     ;; first cruise through sc-preferred-attribution-list looking for
  1234.     ;; a match in either sc-attributions or sc-mail-info.  if the
  1235.     ;; element is "sc-consult", then we have to do the alist
  1236.     ;; consultation phase
  1237.     (while attriblist
  1238.       (let* ((preferred (car attriblist)))
  1239.     (cond
  1240.      ((string= preferred "sc-consult")
  1241.       ;; we've been told to consult the attribution vs. mail
  1242.       ;; header key alist.  we do this until we find a match in
  1243.       ;; the sc-attrib-selection-list.  if we do not find a match,
  1244.       ;; we continue scanning attriblist
  1245.       (let ((attrib (sc-scan-info-alist sc-attrib-selection-list)))
  1246.         (cond
  1247.          ((not attrib)
  1248.           (setq attriblist (cdr attriblist)))
  1249.          ((stringp attrib)
  1250.           (setq attribution attrib
  1251.             attriblist nil))
  1252.          ((listp attrib)
  1253.           (setq attribution (eval attrib)
  1254.             attriblist nil))
  1255.          (t (error "%s did not evaluate to a string or list!"
  1256.                "sc-attrib-selection-list"))
  1257.          )))
  1258.      ((setq attribution (cdr (assoc preferred sc-attributions)))
  1259.       (setq attriblist nil))
  1260.      (t
  1261.       (setq attriblist (cdr attriblist)))
  1262.      )))
  1263.  
  1264.     ;; if preference was not found, we may use a secondary method to
  1265.     ;; find a valid attribution
  1266.     (if (and (not attribution)
  1267.          (not sc-use-only-preference-p))
  1268.     ;; secondary method tries to find a preference in this order
  1269.     ;; 1. sc-lastchoice
  1270.     ;; 2. x-attribution
  1271.     ;; 3. firstname
  1272.     ;; 4. lastname
  1273.     ;; 5. initials
  1274.     ;; 6. first non-empty attribution in alist
  1275.     (setq attribution
  1276.           (or (cdr (assoc "sc-lastchoice" sc-attributions))
  1277.           (cdr (assoc "x-attribution" sc-attributions))
  1278.           (cdr (assoc "firstname" sc-attributions))
  1279.           (cdr (assoc "lastname" sc-attributions))
  1280.           (cdr (assoc "initials" sc-attributions))
  1281.           (cdr (car sc-attributions)))))
  1282.  
  1283.     ;; still couldn't find an attribution. we're now limited to using
  1284.     ;; the default attribution, but we'll force a query when this happens
  1285.     (if (not attribution)
  1286.     (setq attribution sc-default-attribution
  1287.           query-p t))
  1288.  
  1289.     ;; create the attribution prefix
  1290.     (setq citation (sc-make-citation attribution))
  1291.  
  1292.     ;; run the post selection hook before querying the user
  1293.     (run-hooks 'sc-attribs-postselect-hook)
  1294.  
  1295.     ;; query for confirmation
  1296.     (if query-p
  1297.     (let* ((query-alist (mapcar (function (lambda (entry)
  1298.                         (list (cdr entry))))
  1299.                     sc-attributions))
  1300.            (minibuffer-local-completion-map
  1301.         sc-minibuffer-local-completion-map)
  1302.            (minibuffer-local-map sc-minibuffer-local-map)
  1303.            (initial attribution)
  1304.            (completer-disable t)    ; in case completer.el is used
  1305.            choice)
  1306.       (setq sc-attrib-or-cite nil)    ; nil==attribution, t==citation
  1307.       (while
  1308.           (catch 'sc-reconfirm
  1309.         (string= "" (setq choice
  1310.                   (if sc-attrib-or-cite
  1311.                       (sc-read-string
  1312.                        "Enter citation prefix: "
  1313.                        citation
  1314.                        'sc-citation-confirmation-history)
  1315.                     (sc-completing-read
  1316.                      "Complete attribution name: "
  1317.                      query-alist nil nil
  1318.                      (cons initial 0)
  1319.                      'sc-attribution-confirmation-history)
  1320.                     )))))
  1321.       (if sc-attrib-or-cite
  1322.           ;; since the citation was chosen, we have to guess at
  1323.           ;; the attribution
  1324.           (setq citation choice
  1325.             attribution (or (sc-guess-attribution citation)
  1326.                     citation))
  1327.         
  1328.         (setq citation (sc-make-citation choice)
  1329.           attribution choice))
  1330.       ))
  1331.  
  1332.     ;; its possible that the user wants to downcase the citation and
  1333.     ;; attribution
  1334.     (if sc-downcase-p
  1335.     (setq citation (downcase citation)
  1336.           attribution (downcase attribution)))
  1337.  
  1338.     ;; set up mail info alist
  1339.     (let* ((ckey "sc-citation")
  1340.        (akey "sc-attribution")
  1341.        (ckeyval (assoc ckey sc-mail-info))
  1342.        (akeyval (assoc akey sc-mail-info)))
  1343.       (if ckeyval
  1344.       (setcdr ckeyval citation)
  1345.     (setq sc-mail-info
  1346.           (append (list (cons ckey citation)) sc-mail-info)))
  1347.       (if akeyval
  1348.       (setcdr akeyval attribution)
  1349.     (setq sc-mail-info
  1350.           (append (list (cons akey attribution)) sc-mail-info))))
  1351.  
  1352.     ;; set the sc-lastchoice attribution
  1353.     (let* ((lkey "sc-lastchoice")
  1354.        (lastchoice (assoc lkey sc-attributions)))
  1355.       (if lastchoice
  1356.       (setcdr lastchoice attribution)
  1357.     (setq sc-attributions
  1358.           (cons (cons lkey attribution) sc-attributions))))
  1359.     ))
  1360.  
  1361.  
  1362. ;; ======================================================================
  1363. ;; filladapt hooks for supercite 3.1. you shouldn't need anything
  1364. ;; extra to make gin-mode understand supercited lines.  Even this
  1365. ;; stuff might not be entirely necessary...
  1366.  
  1367. (defun sc-cite-regexp (&optional root-regexp)
  1368.   "Return a regexp describing a Supercited line.
  1369. The regexp is the concatenation of `sc-citation-leader-regexp',
  1370. `sc-citation-root-regexp', `sc-citation-delimiter-regexp', and
  1371. `sc-citation-separator-regexp'.  If optional ROOT-REGEXP is supplied,
  1372. use it instead of `sc-citation-root-regexp'."
  1373.   (concat sc-citation-leader-regexp
  1374.       (or root-regexp sc-citation-root-regexp)
  1375.       sc-citation-delimiter-regexp
  1376.       sc-citation-separator-regexp))
  1377.  
  1378. (defun sc-make-citation (attribution)
  1379.   "Make a non-nested citation from ATTRIBUTION."
  1380.   (concat sc-citation-leader
  1381.       attribution
  1382.       sc-citation-delimiter
  1383.       sc-citation-separator))
  1384.  
  1385. (defun sc-setup-filladapt ()
  1386.   "Setup `filladapt-prefix-table' to handle Supercited paragraphs."
  1387.   (if (boundp 'filladapt-prefix-table)
  1388.       (let* ((fa-sc-elt 'filladapt-supercite-included-text)
  1389.          (elt (rassq fa-sc-elt filladapt-prefix-table)))
  1390.     (if elt (setcar elt (sc-cite-regexp))
  1391.       (message "Filladapt doesn't seem to know about Supercite.")
  1392.       (beep)))))
  1393.  
  1394.  
  1395. ;; ======================================================================
  1396. ;; citing and unciting regions of text
  1397.  
  1398. (defvar sc-fill-begin 1
  1399.   "Buffer position to begin filling.")
  1400. (defvar sc-fill-line-prefix ""
  1401.   "Fill prefix of previous line")
  1402.  
  1403. ;; filling
  1404. (defun sc-fill-if-different (&optional prefix)
  1405.   "Fill the region bounded by `sc-fill-begin' and point.
  1406. Only fill if optional PREFIX is different than `sc-fill-line-prefix'.
  1407. If `sc-auto-fill-region-p' is nil, do not fill region.  If PREFIX is
  1408. not supplied, initialize fill variables.  This is useful for a regi
  1409. `begin' frame-entry."
  1410.   (if (not prefix)
  1411.       (setq sc-fill-line-prefix ""
  1412.         sc-fill-begin (regi-pos 'bol))
  1413.     (if (and sc-auto-fill-region-p
  1414.          (not (string= prefix sc-fill-line-prefix)))
  1415.     (let ((fill-prefix sc-fill-line-prefix))
  1416.       (if (not (string= fill-prefix ""))
  1417.           (fill-region sc-fill-begin (regi-pos 'bol)))
  1418.       (setq sc-fill-line-prefix prefix
  1419.         sc-fill-begin (regi-pos 'bol))))
  1420.     )
  1421.   nil)
  1422.  
  1423. (defun sc-cite-coerce-cited-line ()
  1424.   "Coerce a Supercited line to look like our style."
  1425.   (let* ((attribution (sc-guess-attribution))
  1426.      (regexp (sc-cite-regexp attribution))
  1427.      (prefix (sc-make-citation attribution)))
  1428.     (if (and attribution
  1429.          (looking-at regexp))
  1430.     (progn
  1431.       (delete-region
  1432.        (match-beginning 0)
  1433.        (save-excursion
  1434.          (goto-char (match-end 0))
  1435.          (if (bolp) (forward-char -1))
  1436.          (point)))
  1437.       (insert prefix)
  1438.       (sc-fill-if-different prefix)))
  1439.     nil))
  1440.  
  1441. (defun sc-cite-coerce-dumb-citer ()
  1442.   "Coerce a non-nested citation that's been cited with a dumb nesting citer."
  1443.   (delete-region (match-beginning 1) (match-end 1))
  1444.   (beginning-of-line)
  1445.   (sc-cite-coerce-cited-line))
  1446.  
  1447. (defun sc-guess-nesting (&optional string)
  1448.   "Guess the citation nesting on the current line.
  1449. If nesting cannot be guessed, nil is returned.  Optional STRING if
  1450. supplied, is used instead of the line point is on in the current
  1451. buffer."
  1452.   (let ((start 0)
  1453.     (string (or string (buffer-substring (regi-pos 'bol) (regi-pos 'eol))))
  1454.     nesting)
  1455.     (and
  1456.      (= start (or (string-match sc-citation-leader-regexp string start) -1))
  1457.      (setq start (match-end 0))
  1458.      (= start (or (string-match sc-citation-delimiter-regexp string start) -1))
  1459.      (setq nesting (sc-submatch 0 string)
  1460.        start (match-end 0))
  1461.      (= start (or (string-match sc-citation-separator-regexp string start) -1))
  1462.      nesting)))
  1463.  
  1464. (defun sc-add-citation-level ()
  1465.   "Add a citation level for nested citation style w/ coersion."
  1466.   (let* ((nesting (sc-guess-nesting))
  1467.      (citation (make-string (1+ (length nesting))
  1468.                 (string-to-char sc-citation-delimiter)))
  1469.      (prefix (concat sc-citation-leader citation sc-citation-separator)))
  1470.     (if (looking-at (sc-cite-regexp ""))
  1471.     (delete-region (match-beginning 0) (match-end 0)))
  1472.     (insert prefix)
  1473.     (sc-fill-if-different prefix)))
  1474.  
  1475. (defun sc-cite-line (&optional citation)
  1476.   "Cite a single line of uncited text.
  1477. Optional CITATION overrides any citation automatically selected."
  1478.   (if sc-fixup-whitespace-p
  1479.       (fixup-whitespace))
  1480.   (let ((prefix (or citation
  1481.             (cdr (assoc "sc-citation" sc-mail-info))
  1482.             sc-default-attribution)))
  1483.     (insert prefix)
  1484.     (sc-fill-if-different prefix))
  1485.   nil)
  1486.  
  1487. (defun sc-uncite-line ()
  1488.   "Remove citation from current line."
  1489.   (let ((cited (looking-at (sc-cite-regexp))))
  1490.     (if cited
  1491.     (delete-region (match-beginning 0) (match-end 0))))
  1492.   nil)
  1493.  
  1494. (defun sc-recite-line (regexp)
  1495.   "Remove citation matching REGEXP from current line and recite line."
  1496.   (let ((cited (looking-at (concat "^" regexp)))
  1497.     (prefix (cdr (assoc "sc-citation" sc-mail-info))))
  1498.     (if cited
  1499.     (delete-region (match-beginning 0) (match-end 0)))
  1500.     (insert (or prefix sc-default-attribution))
  1501.     (sc-fill-if-different prefix))
  1502.   nil)
  1503.  
  1504. ;; interactive functions
  1505. (defun sc-cite-region (start end &optional confirm-p)
  1506.   "Cite a region delineated by START and END.
  1507. If optional CONFIRM-P is non-nil, the attribution is confirmed before
  1508. its use in the citation string.  This function first runs
  1509. `sc-pre-cite-hook'."
  1510.   (interactive "r\nP")
  1511.   (undo-boundary)
  1512.   (let ((frame (or (sc-scan-info-alist sc-cite-frame-alist)
  1513.            sc-default-cite-frame))
  1514.     (sc-confirm-always-p (if confirm-p t sc-confirm-always-p)))
  1515.     (run-hooks 'sc-pre-cite-hook)
  1516.     (if (interactive-p)
  1517.     (sc-select-attribution))
  1518.     (regi-interpret frame start end)))
  1519.  
  1520. (defun sc-uncite-region (start end)
  1521.   "Uncite a region delineated by START and END.
  1522. First runs `sc-pre-uncite-hook'."
  1523.   (interactive "r")
  1524.   (undo-boundary)
  1525.   (let ((frame (or (sc-scan-info-alist sc-uncite-frame-alist)
  1526.            sc-default-uncite-frame)))
  1527.     (run-hooks 'sc-pre-uncite-hook)
  1528.     (regi-interpret frame start end)))
  1529.       
  1530. (defun sc-recite-region (start end)
  1531.   "Recite a region delineated by START and END.
  1532. First runs `sc-pre-recite-hook'."
  1533.   (interactive "r")
  1534.   (let ((sc-confirm-always-p t))
  1535.     (sc-select-attribution))
  1536.   (undo-boundary)
  1537.   (let ((frame (or (sc-scan-info-alist sc-recite-frame-alist)
  1538.            sc-default-recite-frame)))
  1539.     (run-hooks 'sc-pre-recite-hook)
  1540.     (regi-interpret frame start end)))
  1541.  
  1542.  
  1543. ;; ======================================================================
  1544. ;; building headers
  1545.  
  1546. (defun sc-hdr (prefix field &optional sep return-nil-p)
  1547.   "Returns a concatenation of PREFIX and FIELD.
  1548. If FIELD is not a string or is the empty string, the empty string will
  1549. be returned.  Optional third argument SEP is concatenated on the end if
  1550. it is a string.  Returns empty string, unless optional RETURN-NIL-P is
  1551. non-nil."
  1552.   (if (and (stringp field)
  1553.        (not (string= field "")))
  1554.       (concat prefix field (or sep ""))
  1555.     (and (not return-nil-p) "")))
  1556.  
  1557. (defun sc-whofrom ()
  1558.   "Return the value of (sc-mail-field \"from\") or nil."
  1559.   (let ((sc-mumble nil))
  1560.     (sc-mail-field "from")))
  1561.  
  1562. (defun sc-no-header ()
  1563.   "Does nothing.  Use this instead of nil to get a blank header."
  1564.   ())
  1565.  
  1566. (defun sc-no-blank-line-or-header()
  1567.   "Similar to `sc-no-header' except it removes the preceeding blank line."
  1568.   (if (not (bobp))
  1569.       (if (and (eolp)
  1570.            (progn (forward-line -1)
  1571.               (or (looking-at mail-header-separator)
  1572.               (and (eq major-mode 'mh-letter-mode)
  1573.                    (mh-in-header-p)))))
  1574.       (progn (forward-line)
  1575.          (let ((kill-lines-magic t))
  1576.            (kill-line))))))
  1577.  
  1578. (defun sc-header-on-said ()
  1579.   "\"On <date>, <from> said:\" unless:
  1580. 1. the \"from\" field cannot be found, in which case nothing is inserted;
  1581. 2. the \"date\" field is missing in which case only the from part is printed."
  1582.   (let ((sc-mumble "")
  1583.     (whofrom (sc-whofrom)))
  1584.     (if whofrom
  1585.     (insert sc-reference-tag-string
  1586.         (sc-hdr "On " (sc-mail-field "date") ", ")
  1587.         whofrom " said:\n"))))
  1588.  
  1589. (defun sc-header-inarticle-writes ()
  1590.   "\"In article <message-id>, <from> writes:\"
  1591. Treats \"message-id\" and \"from\" fields similar to `sc-header-on-said'."
  1592.   (let ((sc-mumble "")
  1593.     (whofrom (sc-mail-field "from")))
  1594.     (if whofrom
  1595.     (insert sc-reference-tag-string
  1596.         (sc-hdr "In article " (sc-mail-field "message-id") ", ")
  1597.         whofrom " writes:\n"))))
  1598.  
  1599. (defun sc-header-regarding-adds ()
  1600.   "\"Regarding <subject>; <from> adds:\"
  1601. Treats \"subject\" and \"from\" fields similar to `sc-header-on-said'."
  1602.   (let ((sc-mumble "")
  1603.     (whofrom (sc-whofrom)))
  1604.     (if whofrom
  1605.     (insert sc-reference-tag-string
  1606.         (sc-hdr "Regarding " (sc-mail-field "subject") "; ")
  1607.         whofrom " adds:\n"))))
  1608.  
  1609. (defun sc-header-attributed-writes ()
  1610.   "\"<sc-attribution>\" == <sc-author> <address> writes:
  1611. Treats these fields in a similar manner to `sc-header-on-said'."
  1612.   (let ((sc-mumble "")
  1613.     (whofrom (sc-whofrom)))
  1614.     (if whofrom
  1615.     (insert sc-reference-tag-string
  1616.         (sc-hdr "\"" (sc-mail-field "sc-attribution") "\" == ")
  1617.         (sc-hdr ""   (sc-mail-field "sc-author") " ")
  1618.         (or (sc-hdr "<" (sc-mail-field "sc-from-address") ">" t)
  1619.             (sc-hdr "<" (sc-mail-field "sc-reply-address") ">"  t)
  1620.             "")
  1621.         " writes:\n"))))
  1622.  
  1623. (defun sc-header-author-writes ()
  1624.   "<sc-author> writes:"
  1625.   (let ((sc-mumble "")
  1626.     (whofrom (sc-whofrom)))
  1627.     (if whofrom
  1628.     (insert sc-reference-tag-string
  1629.         (sc-hdr "" (sc-mail-field "sc-author"))
  1630.         " writes:\n"))))
  1631.  
  1632. (defun sc-header-verbose ()
  1633.   "Very verbose, some say gross."
  1634.   (let ((sc-mumble "")
  1635.     (whofrom (sc-whofrom))
  1636.     (tag sc-reference-tag-string))
  1637.     (if whofrom
  1638.     (insert (sc-hdr (concat tag "On ") (sc-mail-field "date") ",\n")
  1639.         (or (sc-hdr tag (sc-mail-field "sc-author") "\n" t)
  1640.             (concat tag whofrom "\n"))
  1641.         (sc-hdr (concat tag "from the organization of ")
  1642.             (sc-mail-field "organization") "\n")
  1643.         (let ((rtag (concat tag "who can be reached at: ")))
  1644.           (or (sc-hdr rtag (sc-mail-field "sc-from-address") "\n" t)
  1645.               (sc-hdr rtag (sc-mail-field "sc-reply-address")  "\n" t)
  1646.               ""))
  1647.         (sc-hdr
  1648.          (concat tag "(whose comments are cited below with \"")
  1649.          (sc-mail-field "sc-citation") "\"),\n")
  1650.         (sc-hdr (concat tag "had this to say in article ")
  1651.             (sc-mail-field "message-id") "\n")
  1652.         (sc-hdr (concat tag "in newsgroups ")
  1653.             (sc-mail-field "newsgroups") "\n")
  1654.         (sc-hdr (concat tag "concerning the subject of ")
  1655.             (sc-mail-field "subject") "\n")
  1656.         (sc-hdr (concat tag "(see ")
  1657.             (sc-mail-field "references")
  1658.             " for more details)\n")
  1659.         ))))
  1660.  
  1661. ;; Added by Ateve Baur <steve@altair.xemacs.org> Apr-02-1997.
  1662. (defun sc-header-author-email-writes ()
  1663.   "sc-author <email-addr> writes:"
  1664.   (let ((sc-mumble "")
  1665.     (whofrom (sc-whofrom)))
  1666.     (if whofrom
  1667.     (insert sc-reference-tag-string
  1668.         (sc-hdr "" (sc-mail-field "sc-author") " ")
  1669.         (or (sc-hdr "<" (sc-mail-field "sc-from-address") ">" t)
  1670.             (sc-hdr "<" (sc-mail-field "sc-reply-address") ">"  t)
  1671.             "")
  1672.         " writes:\n"))))
  1673.  
  1674.  
  1675. ;; ======================================================================
  1676. ;; header rewrites
  1677.  
  1678. (defconst sc-electric-bufname " *sc-erefs* "
  1679.   "Supercite electric reference mode's buffer name.")
  1680. (defvar sc-eref-style 0
  1681.   "Current electric reference style.")
  1682.  
  1683. (defun sc-valid-index-p (index)
  1684.   "Returns INDEX if it is a valid index into `sc-rewrite-header-list'.
  1685. Otherwise returns nil."
  1686.     ;; a number, and greater than or equal to zero
  1687.     ;; less than or equal to the last index
  1688.     (and (natnump index)
  1689.      (< index (length sc-rewrite-header-list))
  1690.      index))
  1691.  
  1692. (defun sc-eref-insert-selected (&optional nomsg)
  1693.   "Insert the selected reference header in the current buffer.
  1694. Optional NOMSG, if non-nil, inhibits printing messages, unless an
  1695. error occurs."
  1696.   (let ((ref (nth sc-eref-style sc-rewrite-header-list)))
  1697.     (condition-case err
  1698.     (progn
  1699.       (eval ref)
  1700.       (let ((lines (count-lines (point-min) (point-max))))
  1701.         (or nomsg (message "Ref header %d [%d line%s]: %s" 
  1702.                    sc-eref-style lines
  1703.                    (if (= lines 1) "" "s")
  1704.                    ref))))
  1705.       (void-function
  1706.        (progn (message
  1707.            "Symbol's function definition is void: %s (Header %d)"
  1708.            (car (cdr err)) sc-eref-style)
  1709.           (beep)
  1710.           ))
  1711.       )))
  1712.  
  1713. (defun sc-electric-mode (&optional arg)
  1714.   "
  1715. Mode for viewing Supercite reference headers.  Commands are:
  1716. \n\\{sc-electric-mode-map}
  1717.  
  1718. `sc-electric-mode' is not intended to be run interactively, but rather
  1719. accessed through Supercite's electric reference feature.  See
  1720. `sc-insert-reference' for more details.  Optional ARG is the initial
  1721. header style to use, unless not supplied or invalid, in which case
  1722. `sc-preferred-header-style' is used."
  1723.  
  1724.   (let ((info sc-mail-info))
  1725.  
  1726.     (setq sc-eref-style
  1727.       (or (sc-valid-index-p arg)
  1728.           (sc-valid-index-p sc-preferred-header-style)
  1729.           0))
  1730.  
  1731.     (get-buffer-create sc-electric-bufname)
  1732.     ;; set up buffer and enter command loop
  1733.     (save-excursion
  1734.       (save-window-excursion
  1735.     (pop-to-buffer sc-electric-bufname)
  1736.     (kill-all-local-variables)
  1737.     (let ((sc-mail-info info)
  1738.           (buffer-read-only t)
  1739.           (mode-name "SC Electric Refs")
  1740.           (major-mode 'sc-electric-mode))
  1741.       (use-local-map sc-electric-mode-map)
  1742.       (sc-eref-show sc-eref-style)
  1743.       (run-hooks 'sc-electric-mode-hook)
  1744.       (recursive-edit)
  1745.       )))
  1746.  
  1747.     (and sc-eref-style
  1748.      (sc-eref-insert-selected))
  1749.     (kill-buffer sc-electric-bufname)
  1750.     ))
  1751.  
  1752. ;; functions for electric reference mode
  1753. (defun sc-eref-show (index)
  1754.   "Show reference INDEX in `sc-rewrite-header-list'."
  1755.   (let ((msg "No %ing reference headers in list.")
  1756.     (last (length sc-rewrite-header-list)))
  1757.     (setq sc-eref-style
  1758.       (cond
  1759.        ((sc-valid-index-p index) index)
  1760.        ((< index 0)
  1761.         (if sc-electric-circular-p
  1762.         (1- last)
  1763.           (progn (error msg "preced") 0)))
  1764.        ((>= index last)
  1765.         (if sc-electric-circular-p
  1766.         0
  1767.           (progn (error msg "follow") (1- last))))
  1768.        ))
  1769.     (save-excursion
  1770.      (set-buffer sc-electric-bufname)
  1771.      (let ((buffer-read-only nil))
  1772.        (erase-buffer)
  1773.        (goto-char (point-min))
  1774.        (sc-eref-insert-selected)
  1775.        ;; now shrink the window to just contain the electric reference
  1776.        ;; header.
  1777.        (let ((hdrlines (count-lines (point-min) (point-max)))
  1778.          (winlines (1- (window-height))))
  1779.      (if (/= hdrlines winlines)
  1780.          (if (> hdrlines winlines)
  1781.          ;; we have to enlarge the window
  1782.          (enlarge-window (- hdrlines winlines))
  1783.            ;; we have to shrink the window
  1784.            (shrink-window (- winlines (max hdrlines window-min-height)))
  1785.            )))
  1786.        ))))
  1787.  
  1788. (defun sc-eref-next ()
  1789.   "Display next reference in other buffer."
  1790.   (interactive)
  1791.   (sc-eref-show (1+ sc-eref-style)))
  1792.  
  1793. (defun sc-eref-prev ()
  1794.   "Display previous reference in other buffer."
  1795.   (interactive)
  1796.   (sc-eref-show (1- sc-eref-style)))
  1797.  
  1798. (defun sc-eref-setn ()
  1799.   "Set reference header selected as preferred."
  1800.   (interactive)
  1801.   (setq sc-preferred-header-style sc-eref-style)
  1802.   (message "Preferred reference style set to header %d." sc-eref-style))
  1803.  
  1804. (defun sc-eref-goto (refnum)
  1805.   "Show reference style indexed by REFNUM.
  1806. If REFNUM is an invalid index, don't go to that reference and return
  1807. nil."
  1808.   (interactive "NGoto Reference: ")
  1809.   (if (sc-valid-index-p refnum)
  1810.       (sc-eref-show refnum)
  1811.     (error "Invalid reference: %d. (Range: [%d .. %d])"
  1812.        refnum 0 (1- (length sc-rewrite-header-list)))
  1813.     ))
  1814.  
  1815. (defun sc-eref-jump ()
  1816.   "Set reference header to preferred header."
  1817.   (interactive)
  1818.   (sc-eref-show sc-preferred-header-style))
  1819.  
  1820. (defun sc-eref-abort ()
  1821.   "Exit from electric reference mode without inserting reference."
  1822.   (interactive)
  1823.   (setq sc-eref-style nil)
  1824.   (exit-recursive-edit))
  1825.  
  1826. (defun sc-eref-exit ()
  1827.   "Exit from electric reference mode and insert selected reference."
  1828.   (interactive)
  1829.   (exit-recursive-edit))
  1830.  
  1831. (defun sc-insert-reference (arg)
  1832.   "Insert, at point, a reference header in the body of the reply.
  1833. Numeric ARG indicates which header style from `sc-rewrite-header-list'
  1834. to use when rewriting the header.  No supplied ARG indicates use of
  1835. `sc-preferred-header-style'.
  1836.  
  1837. With just `\\[universal-argument]', electric reference insert mode is
  1838. entered, regardless of the value of `sc-electric-references-p'.  See
  1839. `sc-electric-mode' for more information."
  1840.   (interactive "P")
  1841.   (if (consp arg)
  1842.       (sc-electric-mode)
  1843.     (let ((preference (or (sc-valid-index-p arg)
  1844.               (sc-valid-index-p sc-preferred-header-style)
  1845.               sc-preferred-header-style
  1846.               0)))
  1847.       (if sc-electric-references-p
  1848.       (sc-electric-mode preference)
  1849.     (sc-eref-insert-selected t)
  1850.     ))))
  1851.  
  1852.  
  1853. ;; ======================================================================
  1854. ;; variable toggling
  1855.  
  1856. (defun sc-raw-mode-toggle ()
  1857.   "Toggle, in one fell swoop, two important SC variables:
  1858. `sc-fixup-whitespace-p' and `sc-auto-fill-region-p'"
  1859.   (interactive)
  1860.   (setq sc-fixup-whitespace-p (not sc-fixup-whitespace-p)
  1861.     sc-auto-fill-region-p (not sc-auto-fill-region-p))
  1862.   (sc-set-mode-string)
  1863.   (set-buffer-modified-p (buffer-modified-p)))
  1864.  
  1865. (defun sc-toggle-var (variable)
  1866.   "Boolean toggle VARIABLE's value.
  1867. VARIABLE must be a bound symbol.  Nil values change to t, non-nil
  1868. values are changed to nil."
  1869.   (message "%s changed from %s to %s"
  1870.        variable (symbol-value variable)
  1871.        (set-variable variable (not (eval-expression variable))))
  1872.   (sc-set-mode-string))
  1873.  
  1874. (defun sc-set-variable (var)
  1875.   "Set the Supercite VARIABLE.
  1876. This function mimics `set-variable', except that the variable to set
  1877. is determined non-interactively.  The value is queried for in the
  1878. minibuffer exactly the same way that `set-variable' does it.
  1879.  
  1880. You can see the current value of the variable when the minibuffer is
  1881. querying you by typing `C-h'.  Note that the format is changed
  1882. slightly from that used by `set-variable' -- the current value is
  1883. printed just after the variable's name instead of at the bottom of the
  1884. help window."
  1885.   (let* ((minibuffer-help-form
  1886.       '(funcall myhelp))
  1887.      (myhelp
  1888.       (function
  1889.        (lambda ()
  1890.          (with-output-to-temp-buffer "*Help*"
  1891.            (prin1 var)
  1892.            (if (boundp var)
  1893.            (let ((print-length 20))
  1894.              (princ "\t(Current value: ")
  1895.              (prin1 (symbol-value var))
  1896.              (princ ")")))
  1897.            (princ "\n\nDocumentation:\n")
  1898.            (princ (substring (documentation-property
  1899.                   var
  1900.                   'variable-documentation)
  1901.                   1))
  1902.            nil)))))
  1903.     (set var (eval-minibuffer (format "Set %s to value: " var))))
  1904.   (sc-set-mode-string))
  1905.  
  1906. (defmacro sc-toggle-symbol (rootname)
  1907.   (list 'defun (intern (concat "sc-T-" rootname)) '()
  1908.     (list 'interactive)
  1909.     (list 'sc-toggle-var
  1910.           (list 'quote (intern (concat "sc-" rootname "-p"))))))
  1911.  
  1912. (defmacro sc-setvar-symbol (rootname)
  1913.   (list 'defun (intern (concat "sc-S-" rootname)) '()
  1914.     (list 'interactive)
  1915.     (list 'sc-set-variable
  1916.           (list 'quote (intern (concat "sc-" rootname))))))
  1917.  
  1918. (sc-toggle-symbol "confirm-always")
  1919. (sc-toggle-symbol "downcase")
  1920. (sc-toggle-symbol "electric-references")
  1921. (sc-toggle-symbol "auto-fill-region")
  1922. (sc-toggle-symbol "mail-nuke-blank-lines")
  1923. (sc-toggle-symbol "nested-citation")
  1924. (sc-toggle-symbol "electric-circular")
  1925. (sc-toggle-symbol "use-only-preferences")
  1926. (sc-toggle-symbol "fixup-whitespace")
  1927.  
  1928. (sc-setvar-symbol "preferred-attribution-list")
  1929. (sc-setvar-symbol "preferred-header-style")
  1930. (sc-setvar-symbol "mail-nuke-mail-headers")
  1931. (sc-setvar-symbol "mail-header-nuke-list")
  1932. (sc-setvar-symbol "cite-region-limit")
  1933.  
  1934. (defun sc-T-describe ()
  1935.   "
  1936.  
  1937. Supercite provides a number of key bindings which simplify the process
  1938. of setting or toggling certain variables controlling its operation.
  1939.  
  1940. Note on function names in this list: all functions of the form
  1941. `sc-S-<name>' actually call `sc-set-variable' on the corresponding
  1942. `sc-<name>' variable.  All functions of the form `sc-T-<name>' call
  1943. `sc-toggle-var' on the corresponding `sc-<name>-p' variable.
  1944.  
  1945. \\{sc-T-keymap}"
  1946.   (interactive)
  1947.   (describe-function 'sc-T-describe))
  1948.  
  1949. (defun sc-set-mode-string ()
  1950.   "Update the minor mode string to show state of Supercite."
  1951.   (setq sc-mode-string
  1952.     (concat " SC"
  1953.         (if (or sc-auto-fill-region-p
  1954.             sc-fixup-whitespace-p)
  1955.             ":" "")
  1956.         (if sc-auto-fill-region-p "f" "")
  1957.         (if sc-fixup-whitespace-p "w" "")
  1958.         )))
  1959.  
  1960.  
  1961. ;; ======================================================================
  1962. ;; published interface to mail and news readers
  1963.  
  1964. (defun sc-cite-original ()
  1965.   "Workhorse citing function which performs the initial citation.
  1966. This is callable from the various mail and news readers' reply
  1967. function according to the agreed upon standard.  See `sc-describe'
  1968. for more details.  `sc-cite-original' does not do any yanking of the
  1969. original message but it does require a few things:
  1970.  
  1971.      1) The reply buffer is the current buffer.
  1972.  
  1973.      2) The original message has been yanked and inserted into the
  1974.         reply buffer.
  1975.  
  1976.      3) Verbose mail headers from the original message have been
  1977.         inserted into the reply buffer directly before the text of the
  1978.         original message.
  1979.  
  1980.      4) Point is at the beginning of the verbose headers.
  1981.  
  1982.      5) Mark is at the end of the body of text to be cited.
  1983.  
  1984. For Emacs 19's, the region need not be active (and typically isn't
  1985. when this function is called.  Also, the hook `sc-pre-hook' is run
  1986. before, and `sc-post-hook' is run after the guts of this function."
  1987.   (run-hooks 'sc-pre-hook)
  1988.  
  1989.   ;; before we do anything, we want to insert the supercite keymap so
  1990.   ;; we can proceed from here
  1991.   (and sc-mode-map-prefix
  1992.        (local-set-key sc-mode-map-prefix sc-mode-map))
  1993.  
  1994.   ;; hack onto the minor mode alist, if it hasn't been done before,
  1995.   ;; then turn on the minor mode. also, set the minor mode string with
  1996.   ;; the values of fill and fixup whitespace variables
  1997.   (if (not (get 'minor-mode-alist 'sc-minor-mode))
  1998.       (progn
  1999.     (put 'minor-mode-alist 'sc-minor-mode 'sc-minor-mode)
  2000.     (setq minor-mode-alist
  2001.           (cons '(sc-minor-mode sc-mode-string) minor-mode-alist))
  2002.     ))
  2003.   (setq sc-minor-mode t)
  2004.   (sc-set-mode-string)
  2005.  
  2006.   (undo-boundary)
  2007.  
  2008.   ;; grab point and mark since the region is probably not active when
  2009.   ;; this function gets automatically called. we want point to be a
  2010.   ;; mark so any deleting before point works properly
  2011.   (let* ((zmacs-regions nil)        ; for XEmacs
  2012.      (mark-active t)        ; for FSFmacs
  2013.      (point (point-marker))
  2014.      (mark  (copy-marker (mark-marker))))
  2015.   
  2016.     ;; make sure point comes before mark, not all functions are
  2017.     ;; interactive "r"
  2018.     (if (< mark point)
  2019.     (let ((tmp point))
  2020.       (setq point mark
  2021.         mark tmp)))
  2022.  
  2023.     ;; first process mail headers, and populate sc-mail-info
  2024.     (sc-mail-process-headers point mark)
  2025.  
  2026.     ;; now get possible attributions
  2027.     (sc-attribs-chop-address (or (sc-mail-field "from")
  2028.                  (sc-mail-field "reply")
  2029.                  (sc-mail-field "reply-to")
  2030.                  (sc-mail-field "sender")))
  2031.     ;; select the attribution
  2032.     (sc-select-attribution)
  2033.  
  2034.     ;; cite the region, but first check the value of sc-cite-region-limit
  2035.     (let ((linecnt (count-lines point mark)))
  2036.       (and sc-cite-region-limit
  2037.        (if (or (not (numberp sc-cite-region-limit))
  2038.            (<= linecnt sc-cite-region-limit))
  2039.            (progn
  2040.          ;; cite the region and insert the header rewrite
  2041.          (sc-cite-region point mark)
  2042.          (goto-char point)
  2043.          (let ((sc-eref-style (or sc-preferred-header-style 0)))
  2044.            (if sc-electric-references-p
  2045.                (sc-electric-mode sc-eref-style)
  2046.              (sc-eref-insert-selected t))))
  2047.          (beep)
  2048.          (message
  2049.           "Region not cited. %d lines exceeds sc-cite-region-limit: %d"
  2050.           linecnt sc-cite-region-limit))))
  2051.  
  2052.     ;; finally, free the point-marker
  2053.     (set-marker point nil)
  2054.     (set-marker mark nil)
  2055.     )
  2056.   (run-hooks 'sc-post-hook)
  2057.   ;; post hook could have changed the variables
  2058.   (sc-set-mode-string))
  2059.  
  2060.  
  2061. ;; ======================================================================
  2062. ;; bug reporting and miscellaneous commands
  2063.  
  2064. (defun sc-open-line (arg)
  2065.   "Like `open-line', but insert the citation prefix at the front of the line.
  2066. With numeric ARG, inserts that many new lines."
  2067.   (interactive "p")
  2068.   (save-excursion
  2069.     (let ((start (point))
  2070.       (prefix (or (progn (beginning-of-line)
  2071.                  (if (looking-at (sc-cite-regexp))
  2072.                  (sc-submatch 0)))
  2073.               "")))
  2074.       (goto-char start)
  2075.       (open-line arg)
  2076.       (forward-line 1)
  2077.       (while (< 0 arg)
  2078.     (insert prefix)
  2079.     (forward-line 1)
  2080.     (setq arg (1- arg))
  2081.     ))))
  2082.  
  2083. (defun sc-insert-citation (arg)
  2084.   "Insert citation string at beginning of current line if not already cited.
  2085. With `\\[universal-argument]' insert citation even if line is already
  2086. cited."
  2087.   (interactive "P")
  2088.   (save-excursion
  2089.     (beginning-of-line)
  2090.     (if (or (not (looking-at (sc-cite-regexp)))
  2091.         (looking-at "^[ \t]*$")
  2092.         (consp arg))
  2093.     (insert (sc-mail-field "sc-citation"))
  2094.       (error "Line is already cited."))))
  2095.  
  2096. (defun sc-version (arg)
  2097.   "Echo the current version of Supercite in the minibuffer.
  2098. With \\[universal-argument] (universal-argument), or if run non-interactively,
  2099. inserts the version string in the current buffer instead."
  2100.   (interactive "P")
  2101.   (let ((verstr (format "Using Supercite.el %s" sc-version)))
  2102.     (if (or (consp arg)
  2103.         (not (interactive-p)))
  2104.     (insert "`sc-version' says: " verstr)
  2105.       (message verstr))))
  2106.  
  2107. (defun sc-describe ()
  2108.   "
  2109. Supercite is a package which provides a flexible mechanism for citing
  2110. email and news replies.  Please see the associated texinfo file for
  2111. more information."
  2112.   (interactive)
  2113.   (describe-function 'sc-describe))
  2114.  
  2115. (defun sc-submit-bug-report ()
  2116.   "Submit a bug report on Supercite via mail."
  2117.   (interactive)
  2118.   (require 'reporter)
  2119.   (and
  2120.    (y-or-n-p "Do you want to submit a report on Supercite? ")
  2121.    (reporter-submit-bug-report
  2122.     sc-help-address
  2123.     (concat "Supercite version " sc-version)
  2124.     (list
  2125.      'sc-attrib-selection-list
  2126.      'sc-auto-fill-region-p
  2127.      'sc-blank-lines-after-headers
  2128.      'sc-citation-leader
  2129.      'sc-citation-delimiter
  2130.      'sc-citation-separator
  2131.      'sc-citation-leader-regexp
  2132.      'sc-citation-root-regexp
  2133.      'sc-citation-nonnested-root-regexp
  2134.      'sc-citation-delimiter-regexp
  2135.      'sc-citation-separator-regexp
  2136.      'sc-cite-region-limit
  2137.      'sc-confirm-always-p
  2138.      'sc-default-attribution
  2139.      'sc-default-author-name
  2140.      'sc-downcase-p
  2141.      'sc-electric-circular-p
  2142.      'sc-electric-references-p
  2143.      'sc-fixup-whitespace-p
  2144.      'sc-mail-warn-if-non-rfc822-p
  2145.      'sc-mumble
  2146.      'sc-name-filter-alist
  2147.      'sc-nested-citation-p
  2148.      'sc-nuke-mail-headers
  2149.      'sc-nuke-mail-header-list
  2150.      'sc-preferred-attribution-list
  2151.      'sc-preferred-header-style
  2152.      'sc-reference-tag-string
  2153.      'sc-rewrite-header-list
  2154.      'sc-titlecue-regexp
  2155.      'sc-use-only-preference-p
  2156.      ))))
  2157.  
  2158.  
  2159. ;; useful stuff
  2160. (provide 'supercite)
  2161. (run-hooks 'sc-load-hook)
  2162.  
  2163. ;;; supercite.el ends here
  2164.